home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / MacOS 8 Resources / Developer Tools / Mac OS 8 Interfaces & Libraries / Interfaces / CIncludes / Power.h < prev    next >
C/C++ Source or Header  |  1996-05-01  |  36KB  |  1,136 lines
  1. /*
  2.      File:        Power.h
  3.  
  4.      Contains:    Power Manager Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Release:    Universal Interfaces 3.0d3 on Copland DR1
  8.  
  9.      Copyright:    © 1984-1996 by Apple Computer, Inc.  All rights reserved.
  10.  
  11.      Bugs?:        If you find a problem with this file, send the file and version
  12.                  information (from above) and the problem description to:
  13.  
  14.                      Internet:    apple.bugs@applelink.apple.com
  15.                      AppleLink:    APPLE.BUGS
  16.  
  17. */
  18. #ifndef __POWER__
  19. #define __POWER__
  20.  
  21. #ifndef __TYPES__
  22. #include <Types.h>
  23. #endif
  24. #if FOR_SYSTEM7_AND_SYSTEM8_DEPRECATED
  25. #ifndef __MIXEDMODE__
  26. #include <MixedMode.h>
  27. #endif
  28. #endif
  29. #if FOR_SYSTEM8_PREEMPTIVE
  30. #ifndef __KERNEL__
  31. #include <Kernel.h>
  32. #endif
  33. #ifndef __NAMEREGISTRY__
  34. #include <NameRegistry.h>
  35. #endif
  36. #endif
  37.  
  38. #ifdef __cplusplus
  39. extern "C" {
  40. #endif
  41.  
  42. #if PRAGMA_IMPORT_SUPPORTED
  43. #pragma import on
  44. #endif
  45.  
  46. #if PRAGMA_ALIGN_SUPPORTED
  47. #pragma options align=mac68k
  48. #endif
  49.  
  50. #if FOR_SYSTEM8_PREEMPTIVE
  51. /*
  52. ========================================================================================
  53.  
  54.     The top of this file contains the Power Management interfaces used in Copland.
  55.     
  56.     The pre-Copland interfaces are below right after a large and obnoxious comment.
  57.  
  58. ========================================================================================
  59. */
  60. /*
  61. //************************************************************************************
  62.  
  63.     Low level (I/O architecture) interface
  64.     
  65. //************************************************************************************
  66. */
  67. /*
  68. //------------------------------------------------------------------------------------
  69.  
  70.     Power Management usage monitoring.
  71.  
  72.     High level families call PMMonitorUsage for each hardware device they maintain.
  73.     Power management will periodically send messages to the family requesting the
  74.     current UsageCount for each device.
  75.     If power management determines that a device is idle it may be taken off-line.
  76.     Prior to doing so power managment will send a message instructing the family to
  77.     prepare for the device being off-line. When the device is reqired again the family
  78.     uses PMPrepareDevice to instruct power management to bring the device back on-line.
  79.  
  80. //------------------------------------------------------------------------------------
  81. */
  82. typedef UInt32 PMUsageCount;
  83. typedef struct OpaquePMMonitorRef* PMMonitorRef;
  84. extern OSStatus PMMonitorUsage(RegEntryRef *deviceToBeMonitored, ObjectID adminMessageObject, void *refCon, PMMonitorRef *newRef);
  85.  
  86. extern OSStatus PMStopMonitoring(PMMonitorRef ref);
  87.  
  88. /*
  89. //------------------------------------------------------------------------------------
  90.  
  91.     Device Power State Management
  92.     
  93.     If a family maintains a device which is capable of switching between multiple
  94.     power states, the family should inform power management of the device's
  95.     capabilities and wait for messages directing it to change the device's power
  96.     state.
  97.  
  98. //------------------------------------------------------------------------------------
  99. */
  100.  
  101. enum {
  102.     kPMDeviceDescriptionInitialVersion = 1
  103. };
  104.  
  105. typedef OSType PMDeviceStateID;
  106. typedef UInt32 PMDeviceStateFlags;
  107.  
  108. enum {
  109.     kPMDevicePoweredMask        = 0x0001,                        /* device powered vs. not */
  110.     kPMDeviceConfiguredMask        = 0x0002,                        /* internal configuration retained vs. not */
  111.     kPMDeviceUsableMask            = 0x0004,                        /* "on-line" vs "off-line" (usable or not) */
  112.     kPMDevicePowerLowestMask    = 0x0100,                        /* set for device's highest state */
  113.     kPMDevicePowerHighestMask    = 0x0200                        /* set for device's lowest state */
  114. };
  115.  
  116. struct PMDeviceState {
  117.     PMDeviceStateID                 id;                            /* state identifier - not interpreted by power management */
  118.     UInt32                             relativeConsumption;        /* relative ranking of power consumption */
  119.     PMDeviceStateFlags                 flags;                        /* one or more of the bits defined above */
  120. };
  121. typedef struct PMDeviceState PMDeviceState;
  122.  
  123. struct PMDeviceDescriptionHdr {
  124.     UInt32                             version;
  125.     UInt32                             numberOfStates;
  126. };
  127. typedef struct PMDeviceDescriptionHdr PMDeviceDescriptionHdr;
  128.  
  129. struct PMDeviceDescription {
  130.     PMDeviceDescriptionHdr             header;
  131.     PMDeviceState                     states[2];
  132. };
  133. typedef struct PMDeviceDescription PMDeviceDescription;
  134.  
  135. typedef struct OpaquePMManageRef* PMManageRef;
  136. extern OSStatus PMManageDeviceState(RegEntryRef *deviceToBeManaged, ObjectID adminMessageObject, PMDeviceDescription *deviceStates, ByteCount descriptionSize, PMDeviceStateID currentState, void *refCon, PMManageRef *newRef);
  137.  
  138. extern OSStatus PMNewDeviceState(PMManageRef manageRef, PMDeviceDescription *newStates, ByteCount stateSize, PMDeviceStateID currentState);
  139.  
  140. extern OSStatus PMStopManaging(PMManageRef ref);
  141.  
  142. /*
  143. //------------------------------------------------------------------------------------
  144.  
  145.     Power Management notification.
  146.     
  147.     Any entity in the I/O architecture can use these routines to be notified about
  148.     changes to device.
  149.     
  150.     Clients use a mask to specify which device aspects they are interested in and
  151.     also to specify when to be notified. Flags describing the new state are generated
  152.     and delivered with the notification.
  153.     
  154.     If the client is interested in power being removed and re-applied, they can request
  155.     it with (kPMNotifyAlwaysMask | kPMNotifyPowerMask). When the notification is 
  156.     delivered the client can check the new flags against kPMNotifyBeforeMask and
  157.     kPMNotifyAfterMask to determine if the change has already occured or not. And can
  158.     check against kPMDevicePoweredMask to determine if the device will have power or
  159.     not in the new state.
  160.     
  161. //------------------------------------------------------------------------------------
  162. */
  163. typedef UInt32 PMNotifyFlags;
  164.  
  165. enum {
  166.     kPMNotifyPowerMask            = 0x00000001,
  167.     kPMNotifyConfigurationMask    = 0x00000002,
  168.     kPMNotifyUsabilityMask        = 0x00000004,
  169.     kPMNotifyAllMask            = 0x00000007,
  170.     kPMNotifyBeforeMask            = 0x40000000,                    /* notification sent before change */
  171.     kPMNotifyAfterMask            = 0x80000000,                    /* notification sent after change */
  172.     kPMNotifyAlwaysMask            = 0xC0000000                    /* notification sent before and after */
  173. };
  174.  
  175. typedef struct OpaquePMNotifyRef* PMNotifyRef;
  176. extern OSStatus PMNotifyStateChange(RegEntryRef *interestingDevice, ObjectID adminMessageObject, PMNotifyFlags notifyFlags, void *refCon, PMNotifyRef *newRef);
  177.  
  178. extern OSStatus PMStopNotification(PMNotifyRef ref);
  179.  
  180. /*
  181. //------------------------------------------------------------------------------------
  182.  
  183.     Power Management message
  184.     
  185.     This structure is used for all types of power management communication - usage
  186.     monitoring, state change notification, and state change commands.
  187.  
  188. //------------------------------------------------------------------------------------
  189. */
  190.  
  191. enum {
  192.     kPMRetrieveUsageCountMessage = 1,
  193.     kPMChangeDeviceStateMessage    = 2,
  194.     kPMNotifyStateChangeMessage    = 3
  195. };
  196.  
  197. union PMMessageData {
  198.     PMNotifyFlags                     newStateFlags;                /* used in kPMNotifyStateChangeMessage */
  199.     PMDeviceStateID                 targetState;                /* used in kChangeDeviceStateMessage */
  200. };
  201. typedef union PMMessageData PMMessageData;
  202.  
  203. struct PMMessage {
  204.     UInt32                             ampReserved;                /* reserved for use by AdminMessagePort service */
  205.     UInt32                             messageCode;                /* one of the message codes above */
  206.     void *                            refCon;                        /* */
  207.     PMMessageData                     data;                        /* message-specific extra data */
  208. };
  209. typedef struct PMMessage PMMessage;
  210.  
  211. /*
  212. //------------------------------------------------------------------------------------
  213.  
  214.     Restoring an off-line or powered off device to a usable state.
  215.     
  216.     When a device that has been taken off-line or has had its power removed is needed
  217.     again, the following routine should be called. This routine will return when after
  218.     the device has been restored (or has failed to be restored). Part of the restoration
  219.     process is delivering notifications to interested parties - kPMPowerRestore and/or
  220.     kPMPrepareOnLine messages will be delivered and processed before this routine 
  221.     returns.
  222.  
  223. //------------------------------------------------------------------------------------
  224. */
  225. extern OSStatus PMMakeDeviceUsable(RegEntryRef *whichDevice);
  226.  
  227. /*
  228. //------------------------------------------------------------------------------------
  229.  
  230.     Disabling & Re-Enabling power managment of a device.
  231.     
  232.     Power management of a specific device can be disabled - this may be desirable
  233.     because of a resource reservation on some device. 
  234.     Families can implement a family specific API on top of this that can allow
  235.     an application to turn off power management for a particular volume or display
  236.     device.
  237.     
  238.     When power management of some device is disabled usage monitoring will still
  239.     occur, but there will not be any requests to change the device state. The
  240.     domain of which the device is a member will not be changed either.
  241.  
  242. //------------------------------------------------------------------------------------
  243. */
  244. extern OSStatus PMDisablePowerManagement(RegEntryRef *whichDevice);
  245.  
  246. extern OSStatus PMEnablePowerManagement(RegEntryRef *whichDevice);
  247.  
  248. /*
  249. //************************************************************************************
  250.  
  251.     Domain Controller Power Management Plug-In interface.
  252.  
  253. //************************************************************************************
  254. */
  255. /*
  256. //------------------------------------------------------------------------------------
  257.  
  258.     Domain description
  259.  
  260. //------------------------------------------------------------------------------------
  261. */
  262.  
  263. enum {
  264.     kPMDomainDescriptionInitialVersion = 1
  265. };
  266.  
  267. typedef OSType PMDomainID;
  268. typedef OSType PMDomainLevelID;
  269. typedef UInt32 PMDomainLevelFlags;
  270.  
  271. enum {
  272.     kPMDomainOffMask            = 0x0000,
  273.     kPMDomainFreezeMask            = (kPMDevicePoweredMask | kPMDeviceConfiguredMask),
  274.     kPMDomainReducedMask        = (kPMDomainFreezeMask | kPMDeviceUsableMask),
  275.     kPMDomainFullMask            = (kPMDomainReducedMask | kPMDevicePowerHighestMask)
  276. };
  277.  
  278. struct PMDomainLevel {
  279.     PMDomainLevelID                 levelID;
  280.     PMDomainLevelFlags                 flags;
  281. };
  282. typedef struct PMDomainLevel PMDomainLevel;
  283.  
  284. struct PMDomainDescriptionHdr {
  285.     UInt32                             descriptionVersion;
  286.     PMDomainID                         domainID;
  287.     UInt32                             numberOfLevels;
  288. };
  289. typedef struct PMDomainDescriptionHdr PMDomainDescriptionHdr;
  290.  
  291. struct PMDomainDescription {
  292.     PMDomainDescriptionHdr             header;
  293.     PMDomainLevel                     levels[2];
  294. };
  295. typedef struct PMDomainDescription PMDomainDescription;
  296.  
  297. /*
  298. //------------------------------------------------------------------------------------
  299.  
  300.     Domain plugin. 
  301.     Plugin init routine returns pointer to a domain description as an out parameter.
  302.  
  303. //------------------------------------------------------------------------------------
  304. */
  305.  
  306. enum {
  307.     kPMDomainPluginVersion        = 0x01000000
  308. };
  309.  
  310. typedef OSStatus (*PMDomainPluginInitProc)(PMDomainDescription **domain, UInt32 *numberOfDomains);
  311. typedef OSStatus (*PMDomainPluginSetLevelProc)(PMDomainID domainID, PMDomainLevelID levelID);
  312. struct PMDomainPluginDispatchTable {
  313.     UInt32                             version;
  314.     UInt32                             reserved[3];
  315.  
  316.     PMDomainPluginInitProc             init;
  317.     PMDomainPluginSetLevelProc         setLevel;
  318. };
  319. typedef struct PMDomainPluginDispatchTable PMDomainPluginDispatchTable;
  320.  
  321. /*
  322. //************************************************************************************
  323.  
  324.     Platform plugin.
  325.     
  326. //************************************************************************************
  327. */
  328.  
  329. enum {
  330.     kPMPlatformPluginVersion    = 0x01000000
  331. };
  332.  
  333. typedef OSStatus (*PMSleepProc)(OSType *services, UInt32 numberOfServices);
  334. typedef OSStatus (*PMHibernateProc)(OSType *services, UInt32 numberOfServices);
  335. typedef OSStatus (*PMShutdownProc)(OSType *services, UInt32 numberOfServices);
  336. typedef OSStatus (*PMRestartProc)(OSType *services, UInt32 numberOfServices);
  337. struct PMPlatformPlugin {
  338.     UInt32                             version;
  339.     UInt32                             reserved[3];
  340.  
  341.     PMSleepProc                     sleep;
  342.     PMHibernateProc                 hibernate;
  343.     PMShutdownProc                     shutdown;
  344.  
  345.     PMRestartProc                     restart;
  346. };
  347. typedef struct PMPlatformPlugin PMPlatformPlugin;
  348.  
  349. /*
  350. //************************************************************************************
  351.  
  352.     High level (application) interface.
  353.     
  354. //************************************************************************************
  355. */
  356. /*
  357.     Disk timer: the time a disk must be idle before it is spun down (or other
  358.     power management actions are taken). Applies to all disks, but each disk
  359.     has its own timer (one can stay spun up while the others are spun down).
  360.     
  361.     The minimum will be enforced.
  362.     
  363.     These API control system-wide parameters for the power management of disk devices.
  364.     For control over a specific disk see the <Block Storage or File System> API.
  365.     
  366.     
  367. */
  368.  
  369. enum {
  370.     kPMDiskSpinDownDisabled        = 0
  371. };
  372.  
  373. extern OSStatus PMSetDiskSpinDownTimeout(UInt32 seconds);
  374.  
  375. extern UInt32 PMGetDiskSpinDownTimeout(void );
  376.  
  377. extern UInt32 PMGetMinimumDiskSpinDownTimeout(void );
  378.  
  379. /*
  380.     Display timer: the period of time in which there has been no user input
  381.     before a display is dimmed or turned off. Applies to all displays, but
  382.     each display has its own timer.
  383.     
  384.     The minimum will be enforced.
  385. */
  386.  
  387. enum {
  388.     kPMDisplayDimmingDisabled    = 0
  389. };
  390.  
  391. extern OSStatus PMSetDisplayDimmingTimeout(UInt32 seconds);
  392.  
  393. extern UInt32 PMGetDisplayDimmingTimeout(void );
  394.  
  395. extern UInt32 PMGetMinimumDisplayDimmingTimeout(void );
  396.  
  397. /*
  398.     Idle state timer: the period of time in which all devices must be idle 
  399.     before the system is [?]. Basically, this is the timer for whatever action 
  400.     the user chose to happen when the system is idle. Could be sleep, hibernate,
  401.     or shutdown. If the user has explicitly disabled any action the    routines 
  402.     return an error.
  403.     
  404.     The minimum will be enforced and will be greater than or equal to the
  405.     maximum of disk spin down and display dimming times.
  406. */
  407.  
  408. enum {
  409.     kPMIdleStateDisabled        = 0
  410. };
  411.  
  412. extern OSStatus PMSetIdleStateTimeout(UInt32 seconds);
  413.  
  414. extern UInt32 PMGetIdleStateTimeout(void );
  415.  
  416. extern UInt32 PMGetMinimumIdleStateTimeout(void );
  417.  
  418. /*
  419.     Idle state: routines to get and set the action to be taken when power
  420.     management has determined that the system is idle.
  421.         Disabled: nothing happens when the machine is idle
  422.         Sleep is a soft definition - depends on the hardware: differs 
  423.         between portable and desktop systems.
  424.         Hibernate: save everthing and shutdown, on boot reload the saved
  425.         state.
  426.         Shutdown: just shutdown, nothing restored on boot.
  427. */
  428.  
  429. enum {
  430.     kPMIdleStateKindShutdown    = 1,
  431.     kPMIdleStateKindHibernate    = 2,
  432.     kPMIdleStateKindSleep        = 3
  433. };
  434.  
  435. extern OSStatus PMSetIdleStateKind(UInt32 idleStateKind);
  436.  
  437. extern UInt32 PMGetIdleStateKind(void );
  438.  
  439. /*
  440.     Misc. timers: These allow for programmable shutdown and power on. These are 
  441.     real absolute times - turn off at 6:00pm Jan 12 and back on at 8:00am Feb 1. 
  442.     The 'DateAndTimeSpec' is a made-up placeholder.
  443.     
  444.     Shutdown is a real shutdown.
  445.     IdleAction puts the machine into the chosen idle state - if the machine is
  446.     shutdown at the that time nothing happens.
  447.     PowerOn is either a normal boot or a return-from-idle depending on whether
  448.     the system is shutdown or is in its idle state.
  449. */
  450. #define kPMClearTime (ConstTimeObjectPtr) NULL
  451. extern OSStatus PMSetShutdownTime(ConstTimeObjectPtr when);
  452.  
  453. extern OSStatus PMGetShutdownTime(TimeObjectPtr when);
  454.  
  455. extern OSStatus PMSetIdleStateTime(ConstTimeObjectPtr when);
  456.  
  457. extern OSStatus PMGetIdleStateTime(TimeObjectPtr when);
  458.  
  459. extern OSStatus PMSetPowerOnTime(ConstTimeObjectPtr when);
  460.  
  461. extern OSStatus PMGetPowerOnTime(TimeObjectPtr when);
  462.  
  463. /*    Immediate control over system state*/
  464. extern OSStatus PMRestart(void );
  465.  
  466. extern OSStatus PMEnterIdleState(UInt32 idleStateKind);
  467.  
  468. /*
  469. //------------------------------------------------------------------------------------
  470.  
  471.     Other high level API.
  472.     
  473.     Other families may want to implement their own power management API that is built
  474.     on top of the API presented here. Examples are the ability to turn off power
  475.     management of a specific storage volume or a specific graphics display. The battery
  476.     family will want/need to export a high level API that can show battery state.
  477.  
  478. //------------------------------------------------------------------------------------
  479. */
  480. /*
  481. //************************************************************************************
  482.  
  483.     User activity monitoring.
  484.     
  485.     These routine are used by software that is interested in the lack of and resumption
  486.     of user activity. The usage model is as follows: software requests to be notified
  487.     when all user activity has ceased for a specified amount of time. Once that
  488.     notification has been delivered any user activity will cause the second notification
  489.     to be delivered immediately. After delivery of the resume notification, the reference
  490.     is invalid and software must request notification again if it so desires.
  491.     
  492. //************************************************************************************
  493. */
  494. typedef struct OpaquePMUserMonitorRef* PMUserMonitorRef;
  495. extern OSStatus PMMonitorUserActivity(UInt32 minutesIdle, KernelNotification *howToNotifyIdle, KernelNotification *howToNotifyResume, PMUserMonitorRef *newRef);
  496.  
  497. extern OSStatus PMCancelMonitoring(PMUserMonitorRef refToCancel);
  498.  
  499. #endif
  500. /*
  501. **************************************************************************************
  502.  
  503.  
  504.     Everything below this comment is the System 7.x Power Manager
  505.     
  506.     This comment is really large and obnoxious so that the separation can be easily
  507.     found when scrolling through the file.
  508.  
  509.  
  510. **************************************************************************************
  511. */
  512. #if FOR_SYSTEM7_AND_SYSTEM8_DEPRECATED
  513.  
  514. enum {
  515.                                                                 /* Bit positions for ModemByte */
  516.     modemOnBit                    = 0,
  517.     ringWakeUpBit                = 2,
  518.     modemInstalledBit            = 3,
  519.     ringDetectBit                = 4,
  520.     modemOnHookBit                = 5,                            /* masks for ModemByte */
  521.     modemOnMask                    = 0x01,
  522.     ringWakeUpMask                = 0x04,
  523.     modemInstalledMask            = 0x08,
  524.     ringDetectMask                = 0x10,
  525.     modemOnHookMask                = 0x20,                            /* bit positions for BatteryByte */
  526.     chargerConnBit                = 0,
  527.     hiChargeBit                    = 1,
  528.     chargeOverFlowBit            = 2,
  529.     batteryDeadBit                = 3,
  530.     batteryLowBit                = 4,
  531.     connChangedBit                = 5,                            /* masks for BatteryByte */
  532.     chargerConnMask                = 0x01,
  533.     hiChargeMask                = 0x02,
  534.     chargeOverFlowMask            = 0x04,
  535.     batteryDeadMask                = 0x08,
  536.     batteryLowMask                = 0x10,
  537.     connChangedMask                = 0x20
  538. };
  539.  
  540.  
  541. enum {
  542.                                                                 /* commands to SleepQRec sleepQProc */
  543.     sleepRequest                = 1,
  544.     sleepDemand                    = 2,
  545.     sleepWakeUp                    = 3,
  546.     sleepRevoke                    = 4,
  547.     sleepUnlock                    = 4,
  548.     sleepDeny                    = 5,
  549.     sleepNow                    = 6,
  550.     dozeDemand                    = 7,
  551.     dozeWakeUp                    = 8,
  552.     dozeRequest                    = 9,                            /* SleepQRec.sleepQFlags */
  553.     noCalls                        = 1,
  554.     noRequest                    = 2,
  555.     slpQType                    = 16,
  556.     sleepQType                    = 16
  557. };
  558.  
  559. /* bits in bitfield returned by PMFeatures */
  560.  
  561. enum {
  562.     hasWakeupTimer                = 0,                            /* 1=wakeup timer is supported                        */
  563.     hasSharedModemPort            = 1,                            /* 1=modem port shared by SCC and internal modem    */
  564.     hasProcessorCycling            = 2,                            /* 1=processor cycling is supported                    */
  565.     mustProcessorCycle            = 3,                            /* 1=processor cycling should not be turned off        */
  566.     hasReducedSpeed                = 4,                            /* 1=processor can be started up at reduced speed    */
  567.     dynamicSpeedChange            = 5,                            /* 1=processor speed can be switched dynamically    */
  568.     hasSCSIDiskMode                = 6,                            /* 1=SCSI Disk Mode is supported                    */
  569.     canGetBatteryTime            = 7,                            /* 1=battery time can be calculated                    */
  570.     canWakeupOnRing                = 8,                            /* 1=can wakeup when the modem detects a ring        */
  571.     hasDimmingSupport            = 9,                            /* 1=has dimming support built in                    */
  572.     hasStartupTimer                = 10                            /* 1=startup timer is supported                        */
  573. };
  574.  
  575. /* bits in bitfield returned by GetIntModemInfo and set by SetIntModemState */
  576.  
  577. enum {
  578.     hasInternalModem            = 0,                            /* 1=internal modem installed                        */
  579.     intModemRingDetect            = 1,                            /* 1=internal modem has detected a ring                */
  580.     intModemOffHook                = 2,                            /* 1=internal modem is off hook                        */
  581.     intModemRingWakeEnb            = 3,                            /* 1=wakeup on ring is enabled                        */
  582.     extModemSelected            = 4,                            /* 1=external modem selected                        */
  583.     modemSetBit                    = 15                            /* 1=set bit, 0=clear bit (SetIntModemState)        */
  584. };
  585.  
  586. /* bits in BatteryInfo.flags                                     */
  587. /* ("chargerConnected" doesn't mean the charger is plugged in)    */
  588.  
  589. enum {
  590.     batteryInstalled            = 7,                            /* 1=battery is currently connected                    */
  591.     batteryCharging                = 6,                            /* 1=battery is being charged                        */
  592.     chargerConnected            = 5                                /* 1=charger is connected to the PowerBook            */
  593. };
  594.  
  595.  
  596. enum {
  597.     HDPwrQType                    = 0x4844,                        /* 'HD' hard disk spindown queue element type            */
  598.     PMgrStateQType                = 0x504D                        /* 'PM' Power Manager state queue element type            */
  599. };
  600.  
  601. /* client notification bits in PMgrQueueElement.pmNotifyBits */
  602.  
  603. enum {
  604.     pmSleepTimeoutChanged        = 0,
  605.     pmSleepEnableChanged        = 1,
  606.     pmHardDiskTimeoutChanged    = 2,
  607.     pmHardDiskSpindownChanged    = 3,
  608.     pmDimmingTimeoutChanged        = 4,
  609.     pmDimmingEnableChanged        = 5,
  610.     pmDiskModeAddressChanged    = 6,
  611.     pmProcessorCyclingChanged    = 7,
  612.     pmProcessorSpeedChanged        = 8,
  613.     pmWakeupTimerChanged        = 9,
  614.     pmStartupTimerChanged        = 10,
  615.     pmHardDiskPowerRemovedbyUser = 11
  616. };
  617.  
  618. /* System Activity Selectors */
  619.  
  620. enum {
  621.     OverallAct                    = 0,                            /* general type of activity                            */
  622.     UsrActivity                    = 1,                            /* user specific type of activity                    */
  623.     NetActivity                    = 2,                            /* network specific activity                        */
  624.     HDActivity                    = 3                                /* Hard Drive activity                                */
  625. };
  626.  
  627. /* Storage Media sleep mode defines */
  628.  
  629. enum {
  630.     kMediaModeOn                = 0,                            /* Media active (Drive spinning and at full power)    */
  631.     kMediaModeStandBy            = 1,                            /* Media standby (not implemented)    */
  632.     kMediaModeSuspend            = 2,                            /* Media Idle (not implemented)    */
  633.     kMediaModeOff                = 3                                /* Media Sleep (Drive not spinning and at min power, max recovery time)    */
  634. };
  635.  
  636.  
  637. enum {
  638.     kMediaPowerCSCode            = 70
  639. };
  640.  
  641. struct ActivityInfo {
  642.     short                             ActivityType;                /* Type of activity to be fetched.  Same as UpdateSystemActivity Selectors */
  643.     unsigned long                     ActivityTime;                /* Time of last activity (in ticks) of specified type. */
  644. };
  645. typedef struct ActivityInfo ActivityInfo;
  646.  
  647. /* information returned by GetScaledBatteryInfo */
  648. struct BatteryInfo {
  649.     UInt8                             flags;                        /* misc flags (see below)                            */
  650.     UInt8                             warningLevel;                /* scaled warning level (0-255)                        */
  651.     UInt8                             reserved;                    /* reserved for internal use                        */
  652.     UInt8                             batteryLevel;                /* scaled battery level (0-255)                        */
  653. };
  654. typedef struct BatteryInfo BatteryInfo;
  655.  
  656. typedef SInt8 ModemByte;
  657. typedef SInt8 BatteryByte;
  658. typedef long PMResultCode;
  659. typedef struct SleepQRec SleepQRec;
  660. typedef SleepQRec *SleepQRecPtr;
  661. typedef struct HDQueueElement HDQueueElement;
  662. typedef struct PMgrQueueElement PMgrQueueElement;
  663. /*
  664.         This ProcPtr uses register based parameters on the 68k and cannot
  665.         be written in or called from a high-level language without the help of
  666.         mixed mode or assembly glue.
  667.  
  668.             typedef pascal long (*SleepQProcPtr)(long message, SleepQRecPtr qRecPtr);
  669.  
  670. */
  671. typedef pascal void (*HDSpindownProcPtr)(HDQueueElement *theElement);
  672. typedef pascal void (*PMgrStateChangeProcPtr)(PMgrQueueElement *theElement, long stateBits);
  673.  
  674. #if GENERATINGCFM
  675. typedef UniversalProcPtr SleepQUPP;
  676. typedef UniversalProcPtr HDSpindownUPP;
  677. typedef UniversalProcPtr PMgrStateChangeUPP;
  678. #else
  679. typedef Register68kProcPtr SleepQUPP;
  680. typedef HDSpindownProcPtr HDSpindownUPP;
  681. typedef PMgrStateChangeProcPtr PMgrStateChangeUPP;
  682. #endif
  683. struct SleepQRec {
  684.     SleepQRecPtr                     sleepQLink;                    /* pointer to next queue element                */
  685.     short                             sleepQType;                    /* queue element type (must be SleepQType)        */
  686.     SleepQUPP                         sleepQProc;                    /* pointer to sleep universal proc ptr            */
  687.     short                             sleepQFlags;                /* flags                                        */
  688. };
  689.  
  690. struct HDQueueElement {
  691.     struct HDQueueElement *            hdQLink;                    /* pointer to next queue element                */
  692.     short                             hdQType;                    /* queue element type (must be HDPwrQType)        */
  693.     short                             hdFlags;                    /* miscellaneous flags                            */
  694.     HDSpindownUPP                     hdProc;                        /* pointer to routine to call                    */
  695.     long                             hdUser;                        /* user-defined (variable storage, etc.)        */
  696. };
  697.  
  698. struct PMgrQueueElement {
  699.     struct PMgrQueueElement *        pmQLink;                    /* pointer to next queue element                */
  700.     short                             pmQType;                    /* queue element type (must be PMgrStateQType)    */
  701.     short                             pmFlags;                    /* miscellaneous flags                            */
  702.     long                             pmNotifyBits;                /* bitmap of which changes to be notified for    */
  703.     PMgrStateChangeUPP                 pmProc;                        /* pointer to routine to call                    */
  704.     long                             pmUser;                        /* user-defined (variable storage, etc.)        */
  705. };
  706.  
  707. struct BatteryTimeRec {
  708.     unsigned long                     expectedBatteryTime;        /* estimated battery time remaining (seconds)    */
  709.     unsigned long                     minimumBatteryTime;            /* minimum battery time remaining (seconds)        */
  710.     unsigned long                     maximumBatteryTime;            /* maximum battery time remaining (seconds)        */
  711.     unsigned long                     timeUntilCharged;            /* time until battery is fully charged (seconds)*/
  712. };
  713. typedef struct BatteryTimeRec BatteryTimeRec;
  714.  
  715. struct WakeupTime {
  716.     unsigned long                     wakeTime;                    /* wakeup time (same format as current time)        */
  717.     Boolean                         wakeEnabled;                /* 1=enable wakeup timer, 0=disable wakeup timer    */
  718.     SInt8                             filler;
  719. };
  720. typedef struct WakeupTime WakeupTime;
  721.  
  722. struct StartupTime {
  723.     unsigned long                     startTime;                    /* startup time (same format as current time)        */
  724.     Boolean                         startEnabled;                /* 1=enable startup timer, 0=disable startup timer    */
  725.     SInt8                             filler;
  726. };
  727. typedef struct StartupTime StartupTime;
  728.  
  729. extern pascal OSErr DisableWUTime(void );
  730.  
  731. extern pascal OSErr SetWUTime(long WUTime);
  732.  
  733. extern pascal OSErr GetWUTime(long *WUTime, Byte *WUFlag);
  734.  
  735. extern pascal OSErr BatteryStatus(Byte *Status, Byte *Power);
  736.  
  737. extern pascal OSErr ModemStatus(Byte *Status);
  738.  
  739.  
  740. #if GENERATING68K && !GENERATINGCFM
  741. #pragma parameter __D0 IdleUpdate
  742. #endif
  743. extern pascal long IdleUpdate(void )
  744.  ONEWORDINLINE(0xA285);
  745.  
  746.  
  747. #if GENERATING68K && !GENERATINGCFM
  748. #pragma parameter __D0 GetCPUSpeed
  749. #endif
  750. extern pascal long GetCPUSpeed(void )
  751.  TWOWORDINLINE(0x70FF, 0xA485);
  752.  
  753. extern pascal void EnableIdle(void )
  754.  TWOWORDINLINE(0x7000, 0xA485);
  755.  
  756. extern pascal void DisableIdle(void )
  757.  TWOWORDINLINE(0x7001, 0xA485);
  758.  
  759.  
  760. #if GENERATING68K && !GENERATINGCFM
  761. #pragma parameter SleepQInstall(__A0)
  762. #endif
  763. extern pascal void SleepQInstall(SleepQRecPtr qRecPtr)
  764.  ONEWORDINLINE(0xA28A);
  765.  
  766.  
  767. #if GENERATING68K && !GENERATINGCFM
  768. #pragma parameter SleepQRemove(__A0)
  769. #endif
  770. extern pascal void SleepQRemove(SleepQRecPtr qRecPtr)
  771.  ONEWORDINLINE(0xA48A);
  772.  
  773. extern pascal void AOn(void )
  774.  TWOWORDINLINE(0x7004, 0xA685);
  775.  
  776. extern pascal void AOnIgnoreModem(void )
  777.  TWOWORDINLINE(0x7005, 0xA685);
  778.  
  779. extern pascal void BOn(void )
  780.  TWOWORDINLINE(0x7000, 0xA685);
  781.  
  782. extern pascal void AOff(void )
  783.  TWOWORDINLINE(0x7084, 0xA685);
  784.  
  785. extern pascal void BOff(void )
  786.  TWOWORDINLINE(0x7080, 0xA685);
  787.  
  788. /* Public Power Management API (NEW!) */
  789.  
  790. #if GENERATING68K && !GENERATINGCFM
  791. #pragma parameter __D0 PMSelectorCount
  792. #endif
  793. extern pascal short PMSelectorCount(void )
  794.  TWOWORDINLINE(0x7000, 0xA09E);
  795.  
  796.  
  797. #if GENERATING68K && !GENERATINGCFM
  798. #pragma parameter __D0 PMFeatures
  799. #endif
  800. extern pascal unsigned long PMFeatures(void )
  801.  TWOWORDINLINE(0x7001, 0xA09E);
  802.  
  803.  
  804. #if GENERATING68K && !GENERATINGCFM
  805. #pragma parameter __D0 GetSleepTimeout
  806. #endif
  807. extern pascal UInt8 GetSleepTimeout(void )
  808.  TWOWORDINLINE(0x7002, 0xA09E);
  809.  
  810.  
  811. #if GENERATING68K && !GENERATINGCFM
  812. #pragma parameter SetSleepTimeout(__D0)
  813. #endif
  814. extern pascal void SetSleepTimeout(UInt8 timeout)
  815.  FOURWORDINLINE(0x4840, 0x303C, 0x0003, 0xA09E);
  816.  
  817.  
  818. #if GENERATING68K && !GENERATINGCFM
  819. #pragma parameter __D0 GetHardDiskTimeout
  820. #endif
  821. extern pascal UInt8 GetHardDiskTimeout(void )
  822.  TWOWORDINLINE(0x7004, 0xA09E);
  823.  
  824.  
  825. #if GENERATING68K && !GENERATINGCFM
  826. #pragma parameter SetHardDiskTimeout(__D0)
  827. #endif
  828. extern pascal void SetHardDiskTimeout(UInt8 timeout)
  829.  FOURWORDINLINE(0x4840, 0x303C, 0x0005, 0xA09E);
  830.  
  831.  
  832. #if GENERATING68K && !GENERATINGCFM
  833. #pragma parameter __D0 HardDiskPowered
  834. #endif
  835. extern pascal Boolean HardDiskPowered(void )
  836.  TWOWORDINLINE(0x7006, 0xA09E);
  837.  
  838.  
  839. #if GENERATING68K && !GENERATINGCFM
  840. #pragma parameter SpinDownHardDisk
  841. #endif
  842. extern pascal void SpinDownHardDisk(void )
  843.  TWOWORDINLINE(0x7007, 0xA09E);
  844.  
  845.  
  846. #if GENERATING68K && !GENERATINGCFM
  847. #pragma parameter __D0 IsSpindownDisabled
  848. #endif
  849. extern pascal Boolean IsSpindownDisabled(void )
  850.  TWOWORDINLINE(0x7008, 0xA09E);
  851.  
  852.  
  853. #if GENERATING68K && !GENERATINGCFM
  854. #pragma parameter SetSpindownDisable(__D0)
  855. #endif
  856. extern pascal void SetSpindownDisable(Boolean setDisable)
  857.  FOURWORDINLINE(0x4840, 0x303C, 0x0009, 0xA09E);
  858.  
  859.  
  860. #if GENERATING68K && !GENERATINGCFM
  861. #pragma parameter __D0 HardDiskQInstall(__A0)
  862. #endif
  863. extern pascal OSErr HardDiskQInstall(HDQueueElement *theElement)
  864.  TWOWORDINLINE(0x700A, 0xA09E);
  865.  
  866.  
  867. #if GENERATING68K && !GENERATINGCFM
  868. #pragma parameter __D0 HardDiskQRemove(__A0)
  869. #endif
  870. extern pascal OSErr HardDiskQRemove(HDQueueElement *theElement)
  871.  TWOWORDINLINE(0x700B, 0xA09E);
  872.  
  873.  
  874. #if GENERATING68K && !GENERATINGCFM
  875. #pragma parameter GetScaledBatteryInfo(__D0, __A0)
  876. #endif
  877. extern pascal void GetScaledBatteryInfo(short whichBattery, BatteryInfo *theInfo)
  878.  FIVEWORDINLINE(0x4840, 0x303C, 0x000C, 0xA09E, 0x2080);
  879.  
  880.  
  881. #if GENERATING68K && !GENERATINGCFM
  882. #pragma parameter AutoSleepControl(__D0)
  883. #endif
  884. extern pascal void AutoSleepControl(Boolean enableSleep)
  885.  FOURWORDINLINE(0x4840, 0x303C, 0x000D, 0xA09E);
  886.  
  887.  
  888. #if GENERATING68K && !GENERATINGCFM
  889. #pragma parameter __D0 GetIntModemInfo
  890. #endif
  891. extern pascal unsigned long GetIntModemInfo(void )
  892.  TWOWORDINLINE(0x700E, 0xA09E);
  893.  
  894.  
  895. #if GENERATING68K && !GENERATINGCFM
  896. #pragma parameter SetIntModemState(__D0)
  897. #endif
  898. extern pascal void SetIntModemState(short theState)
  899.  FOURWORDINLINE(0x4840, 0x303C, 0x000F, 0xA09E);
  900.  
  901.  
  902. #if GENERATING68K && !GENERATINGCFM
  903. #pragma parameter __D0 MaximumProcessorSpeed
  904. #endif
  905. extern pascal short MaximumProcessorSpeed(void )
  906.  TWOWORDINLINE(0x7010, 0xA09E);
  907.  
  908.  
  909. #if GENERATING68K && !GENERATINGCFM
  910. #pragma parameter __D0 CurrentProcessorSpeed
  911. #endif
  912. extern pascal short CurrentProcessorSpeed(void )
  913.  TWOWORDINLINE(0x7011, 0xA09E);
  914.  
  915.  
  916. #if GENERATING68K && !GENERATINGCFM
  917. #pragma parameter __D0 FullProcessorSpeed
  918. #endif
  919. extern pascal Boolean FullProcessorSpeed(void )
  920.  TWOWORDINLINE(0x7012, 0xA09E);
  921.  
  922.  
  923. #if GENERATING68K && !GENERATINGCFM
  924. #pragma parameter __D0 SetProcessorSpeed(__D0)
  925. #endif
  926. extern pascal Boolean SetProcessorSpeed(Boolean fullSpeed)
  927.  FOURWORDINLINE(0x4840, 0x303C, 0x0013, 0xA09E);
  928.  
  929.  
  930. #if GENERATING68K && !GENERATINGCFM
  931. #pragma parameter __D0 GetSCSIDiskModeAddress
  932. #endif
  933. extern pascal short GetSCSIDiskModeAddress(void )
  934.  TWOWORDINLINE(0x7014, 0xA09E);
  935.  
  936.  
  937. #if GENERATING68K && !GENERATINGCFM
  938. #pragma parameter SetSCSIDiskModeAddress(__D0)
  939. #endif
  940. extern pascal void SetSCSIDiskModeAddress(short scsiAddress)
  941.  FOURWORDINLINE(0x4840, 0x303C, 0x0015, 0xA09E);
  942.  
  943.  
  944. #if GENERATING68K && !GENERATINGCFM
  945. #pragma parameter GetWakeupTimer(__A0)
  946. #endif
  947. extern pascal void GetWakeupTimer(WakeupTime *theTime)
  948.  TWOWORDINLINE(0x7016, 0xA09E);
  949.  
  950.  
  951. #if GENERATING68K && !GENERATINGCFM
  952. #pragma parameter SetWakeupTimer(__A0)
  953. #endif
  954. extern pascal void SetWakeupTimer(WakeupTime *theTime)
  955.  TWOWORDINLINE(0x7017, 0xA09E);
  956.  
  957.  
  958. #if GENERATING68K && !GENERATINGCFM
  959. #pragma parameter __D0 IsProcessorCyclingEnabled
  960. #endif
  961. extern pascal Boolean IsProcessorCyclingEnabled(void )
  962.  TWOWORDINLINE(0x7018, 0xA09E);
  963.  
  964.  
  965. #if GENERATING68K && !GENERATINGCFM
  966. #pragma parameter EnableProcessorCycling(__D0)
  967. #endif
  968. extern pascal void EnableProcessorCycling(Boolean enable)
  969.  FOURWORDINLINE(0x4840, 0x303C, 0x0019, 0xA09E);
  970.  
  971.  
  972. #if GENERATING68K && !GENERATINGCFM
  973. #pragma parameter __D0 BatteryCount
  974. #endif
  975. extern pascal short BatteryCount(void )
  976.  TWOWORDINLINE(0x701A, 0xA09E);
  977.  
  978.  
  979. #if GENERATING68K && !GENERATINGCFM
  980. #pragma parameter __D0 GetBatteryVoltage(__D0)
  981. #endif
  982. extern pascal Fixed GetBatteryVoltage(short whichBattery)
  983.  FOURWORDINLINE(0x4840, 0x303C, 0x001B, 0xA09E);
  984.  
  985.  
  986. #if GENERATING68K && !GENERATINGCFM
  987. #pragma parameter GetBatteryTimes(__D0, __A0)
  988. #endif
  989. extern pascal void GetBatteryTimes(short whichBattery, BatteryTimeRec *theTimes)
  990.  FOURWORDINLINE(0x4840, 0x303C, 0x001C, 0xA09E);
  991.  
  992.  
  993. #if GENERATING68K && !GENERATINGCFM
  994. #pragma parameter __D0 GetDimmingTimeout
  995. #endif
  996. extern pascal UInt8 GetDimmingTimeout(void )
  997.  TWOWORDINLINE(0x701D, 0xA09E);
  998.  
  999.  
  1000. #if GENERATING68K && !GENERATINGCFM
  1001. #pragma parameter SetDimmingTimeout(__D0)
  1002. #endif
  1003. extern pascal void SetDimmingTimeout(UInt8 timeout)
  1004.  FOURWORDINLINE(0x4840, 0x303C, 0x001E, 0xA09E);
  1005.  
  1006.  
  1007. #if GENERATING68K && !GENERATINGCFM
  1008. #pragma parameter DimmingControl(__D0)
  1009. #endif
  1010. extern pascal void DimmingControl(Boolean enableSleep)
  1011.  FOURWORDINLINE(0x4840, 0x303C, 0x001F, 0xA09E);
  1012.  
  1013.  
  1014. #if GENERATING68K && !GENERATINGCFM
  1015. #pragma parameter __D0 IsDimmingControlDisabled
  1016. #endif
  1017. extern pascal Boolean IsDimmingControlDisabled(void )
  1018.  TWOWORDINLINE(0x7020, 0xA09E);
  1019.  
  1020.  
  1021. #if GENERATING68K && !GENERATINGCFM
  1022. #pragma parameter __D0 IsAutoSlpControlDisabled
  1023. #endif
  1024. extern pascal Boolean IsAutoSlpControlDisabled(void )
  1025.  TWOWORDINLINE(0x7021, 0xA09E);
  1026.  
  1027.  
  1028. #if GENERATING68K && !GENERATINGCFM
  1029. #pragma parameter __D0 PMgrStateQInstall(__A0)
  1030. #endif
  1031. extern pascal OSErr PMgrStateQInstall(PMgrQueueElement *theElement)
  1032.  TWOWORDINLINE(0x7022, 0xA09E);
  1033.  
  1034.  
  1035. #if GENERATING68K && !GENERATINGCFM
  1036. #pragma parameter __D0 PMgrStateQRemove(__A0)
  1037. #endif
  1038. extern pascal OSErr PMgrStateQRemove(PMgrQueueElement *theElement)
  1039.  TWOWORDINLINE(0x7023, 0xA09E);
  1040.  
  1041.  
  1042. #if GENERATING68K && !GENERATINGCFM
  1043. #pragma parameter __D0 UpdateSystemActivity(__D0)
  1044. #endif
  1045. extern pascal OSErr UpdateSystemActivity(UInt8 activity)
  1046.  FOURWORDINLINE(0x4840, 0x303C, 0x0024, 0xA09E);
  1047.  
  1048.  
  1049. #if GENERATING68K && !GENERATINGCFM
  1050. #pragma parameter __D0 DelaySystemIdle
  1051. #endif
  1052. extern pascal OSErr DelaySystemIdle(void )
  1053.  TWOWORDINLINE(0x7025, 0xA09E);
  1054.  
  1055.  
  1056. #if GENERATING68K && !GENERATINGCFM
  1057. #pragma parameter __D0 GetStartupTimer(__A0)
  1058. #endif
  1059. extern pascal OSErr GetStartupTimer(StartupTime *theTime)
  1060.  TWOWORDINLINE(0x7026, 0xA09E);
  1061.  
  1062.  
  1063. #if GENERATING68K && !GENERATINGCFM
  1064. #pragma parameter __D0 SetStartupTimer(__A0)
  1065. #endif
  1066. extern pascal OSErr SetStartupTimer(StartupTime *theTime)
  1067.  TWOWORDINLINE(0x7027, 0xA09E);
  1068.  
  1069.  
  1070. #if GENERATING68K && !GENERATINGCFM
  1071. #pragma parameter __D0 GetLastActivity(__A0)
  1072. #endif
  1073. extern pascal OSErr GetLastActivity(ActivityInfo *theActivity)
  1074.  TWOWORDINLINE(0x7028, 0xA09E);
  1075.  
  1076.  
  1077. enum {
  1078.     uppSleepQProcInfo = kRegisterBased
  1079.          | RESULT_SIZE(SIZE_CODE(sizeof(long)))
  1080.          | REGISTER_RESULT_LOCATION(kRegisterD0)
  1081.          | REGISTER_ROUTINE_PARAMETER(1, kRegisterD0, SIZE_CODE(sizeof(long)))
  1082.          | REGISTER_ROUTINE_PARAMETER(2, kRegisterA0, SIZE_CODE(sizeof(SleepQRecPtr))),
  1083.     uppHDSpindownProcInfo = kPascalStackBased
  1084.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(HDQueueElement *))),
  1085.     uppPMgrStateChangeProcInfo = kPascalStackBased
  1086.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(PMgrQueueElement *)))
  1087.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long)))
  1088. };
  1089.  
  1090. #if GENERATINGCFM
  1091. #define NewSleepQProc(userRoutine)        \
  1092.         (SleepQUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppSleepQProcInfo, GetCurrentArchitecture())
  1093. #define NewHDSpindownProc(userRoutine)        \
  1094.         (HDSpindownUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppHDSpindownProcInfo, GetCurrentArchitecture())
  1095. #define NewPMgrStateChangeProc(userRoutine)        \
  1096.         (PMgrStateChangeUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppPMgrStateChangeProcInfo, GetCurrentArchitecture())
  1097. #else
  1098. #define NewSleepQProc(userRoutine)        \
  1099.         ((SleepQUPP) (userRoutine))
  1100. #define NewHDSpindownProc(userRoutine)        \
  1101.         ((HDSpindownUPP) (userRoutine))
  1102. #define NewPMgrStateChangeProc(userRoutine)        \
  1103.         ((PMgrStateChangeUPP) (userRoutine))
  1104. #endif
  1105.  
  1106. #if GENERATINGCFM
  1107. #define CallSleepQProc(userRoutine, message, qRecPtr)        \
  1108.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppSleepQProcInfo, (message), (qRecPtr))
  1109. #define CallHDSpindownProc(userRoutine, theElement)        \
  1110.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppHDSpindownProcInfo, (theElement))
  1111. #define CallPMgrStateChangeProc(userRoutine, theElement, stateBits)        \
  1112.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppPMgrStateChangeProcInfo, (theElement), (stateBits))
  1113. #else
  1114. /* (*SleepQUPP) cannot be called from a high-level language without the Mixed Mode Manager */
  1115. #define CallHDSpindownProc(userRoutine, theElement)        \
  1116.         (*(userRoutine))((theElement))
  1117. #define CallPMgrStateChangeProc(userRoutine, theElement, stateBits)        \
  1118.         (*(userRoutine))((theElement), (stateBits))
  1119. #endif
  1120. #endif
  1121.  
  1122. #if PRAGMA_ALIGN_SUPPORTED
  1123. #pragma options align=reset
  1124. #endif
  1125.  
  1126. #if PRAGMA_IMPORT_SUPPORTED
  1127. #pragma import off
  1128. #endif
  1129.  
  1130. #ifdef __cplusplus
  1131. }
  1132. #endif
  1133.  
  1134. #endif /* __POWER__ */
  1135.  
  1136.